package com.Lemon.Zhkuhealth.admin.controller;

import com.Lemon.Zhkuhealh.api.service.IUserService;
import com.Lemon.Zhkuhealth.common.constant.MessageConstant;
import com.Lemon.Zhkuhealth.common.pojo.entity.User;
import com.Lemon.Zhkuhealth.common.util.PageResult;
import com.Lemon.Zhkuhealth.common.util.QueryPageBean;
import com.Lemon.Zhkuhealth.common.util.R;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.web.bind.annotation.*;

/**
 * 用户管理 Controller
 */
@Slf4j
@RestController
@RequestMapping("/user") // 对应前端的 /user 路由
@RequiredArgsConstructor
public class UserController {

    @DubboReference
    private IUserService userService;

    /**
     * 分页查询用户列表
     * URL: /user/findPage
     * @param queryPageBean 查询条件 (包含 currentPage, pageSize, queryString)
     * @return 统一响应结果 (PageResult)
     */
    @PostMapping("/findPage")
    public R findPage(@RequestBody QueryPageBean queryPageBean) {
        try {
            PageResult<User> pageResult = userService.findPage(queryPageBean);
            log.info("查询用户列表成功，总记录数: {}", pageResult.getTotal());
            return new R(true, MessageConstant.QUERY_USER_SUCCESS, pageResult);
        } catch (Exception e) {
            log.error("查询用户列表失败: {}", e.getMessage(), e);
            return new R(false, MessageConstant.QUERY_USER_FAIL);
        }
    }

    /**
     * 新增用户
     * URL: /user/add
     * @param user 用户实体
     * @return 统一响应结果
     */
    @PostMapping("/add")
    public R add(@RequestBody User user) {
        try {
            userService.add(user);
            log.info("新增用户成功: {}", user.getUsername());
            return new R(true, MessageConstant.ADD_USER_SUCCESS);
        } catch (Exception e) {
            log.error("新增用户失败: {}", e.getMessage(), e);
            // 考虑更细致的异常处理，例如处理用户名重复
            if (e.getMessage() != null && e.getMessage().contains("Duplicate entry")) {
                return new R(false, "新增用户失败，用户名已存在！");
            }
            return new R(false, MessageConstant.ADD_USER_FAIL);
        }
    }

    /**
     * 根据ID查询用户信息（用于编辑回显）
     * URL: /user/findById?id=...
     * @param id 用户ID
     * @return 统一响应结果 (User)
     */
    @GetMapping("/findById")
    public R findById(@RequestParam("id") Integer id) {
        try {
            User user = userService.findById(id);
            if (user != null) {
                user.setPassword("");
                log.info("根据ID查询用户成功，ID: {}", id);
                return new R(true, MessageConstant.QUERY_USER_SUCCESS, user);
            } else {
                log.warn("根据ID查询用户失败，ID: {} 不存在", id);
                return new R(false, MessageConstant.QUERY_USER_FAIL);
            }
        } catch (Exception e) {
            log.error("根据ID查询用户失败: {}", e.getMessage(), e);
            return new R(false, MessageConstant.QUERY_USER_FAIL);
        }
    }

    /**
     * 更新用户信息
     * URL: /user/edit
     * @param user 用户实体
     * @return 统一响应结果
     */
    @PostMapping("/edit")
    public R edit(@RequestBody User user) {
        try {
            userService.edit(user);
            log.info("更新用户成功: {}", user.getUsername());
            return new R(true, MessageConstant.EDIT_USER_SUCCESS);
        } catch (Exception e) {
            log.error("更新用户失败: {}", e.getMessage(), e);
            if (e.getMessage() != null && e.getMessage().contains("Duplicate entry")) {
                return new R(false, "更新用户失败，用户名已存在！");
            }
            return new R(false, MessageConstant.EDIT_USER_FAIL);
        }
    }

    /**
     * 根据ID删除用户
     * URL: /user/delete?id=...
     * @param id 用户ID
     * @return 统一响应结果
     */
    @DeleteMapping("/delete")
    public R delete(@RequestParam("id") Integer id) {
        try {
            userService.deleteById(id);
            log.info("删除用户成功，ID: {}", id);
            return new R(true, MessageConstant.DELETE_USER_SUCCESS);
        } catch (Exception e) {
            log.error("删除用户失败: {}", e.getMessage(), e);
            return new R(false, MessageConstant.DELETE_USER_FAIL);
        }
    }

    /**
     * URL: /user/findByUsername?username=...
     * @param username 用户名
     * @return 统一响应结果 (User)
     */
    @GetMapping("/findByUsername")
    public R findByUsername(@RequestParam("username") String username) {
        try {
            User user = userService.findByUsername(username);
            if (user != null) {
                log.info("根据用户名查询用户成功，用户名: {}", username);
                return new R(false, "用户名已存在！"); // 如果查到，说明用户名已存在
            } else {
                log.info("根据用户名查询用户，用户名: {} 不存在", username);
                return new R(true, "用户名可用");
            }
        } catch (Exception e) {
            log.error("根据用户名查询用户失败: {}", e.getMessage(), e);
            return new R(false, MessageConstant.QUERY_USER_FAIL);
        }
    }
    /**
     * 根据用户名和密码查询用户（用于登录验证）
     * URL: /user/login
     * @param user 包含用户名和密码的用户实体
     * @return 统一响应结果 (User对象如果登录成功，否则为null)
     */
    @PostMapping("/login")
    public R findByUsernameAndPassword(@RequestBody User user) {
        try {
            User loggedInUser = userService.findByUsernameAndPassword(user.getUsername(), user.getPassword());
            if (loggedInUser != null) {
                log.info("用户登录成功，用户名: {}", loggedInUser.getUsername());
                loggedInUser.setPassword(null);
                return new R(true, MessageConstant.LOGIN_SUCCESS, loggedInUser);
            } else {
                log.warn("用户登录失败，用户名或密码错误: {}", user.getUsername());
                return new R(false, MessageConstant.LOGIN_FAIL_USERNAME_PASSWORD);
            }
        } catch (Exception e) {
            log.error("用户登录请求异常，用户名: {}: {}", user.getUsername(), e.getMessage(), e);
            return new R(false, MessageConstant.LOGIN_FAIL);
        }
    }
}